/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package logica.validacion;

import java.util.StringTokenizer;
import java.util.regex.Pattern;

/**
 *
 * @author Gonzalo
 */
public class PacienteValidacion extends CapaValidacion {

    /**
     * Determina si el domicilio de una persona es válido.
     *
     * @param calle Nombre de calle y altura
     * @param piso El piso en el cual vive el paciente
     * @param departamento Número de departamento
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es valido, false en caso contrario
     */
    public static boolean validarDomicilio(String calle, String piso,
            String departamento, boolean esObligatorio) {
        boolean esValido = true;
        String calleTemp = calle.toLowerCase();
        String pisoTemp = piso.toLowerCase();
        String departamentoTemp = departamento.toLowerCase();

        if (esObligatorio && calleTemp.isEmpty()) {
                esValido = false;
        }
        
        if (!esObligatorio && calleTemp.isEmpty() && (!pisoTemp.isEmpty() ||
                !departamentoTemp.isEmpty())) {
            esValido = false;
        }


        if (!pisoTemp.isEmpty()) {
            Pattern patronPiso = Pattern.compile("([a-z]*[0-9]*)*");
            if (!patronPiso.matcher(pisoTemp).matches()) {
                esValido = false;
            }
        }

        if (!departamentoTemp.isEmpty()) {
            Pattern patronDepto = Pattern.compile("([a-z]*[0-9]*)*");
            if (!patronDepto.matcher(departamentoTemp).matches()) {
                esValido = false;
            }
        }

        if (calleTemp.length() < 2 && !calleTemp.isEmpty()) {
            esValido = false;
        }

        //Se separa en palabras la calle
        StringTokenizer tokens = new StringTokenizer(calleTemp);
        while (tokens.hasMoreTokens()) {
            String palabra = tokens.nextToken();

            //Cada palabra debe tener al menos dos letras
            if (palabra.length() < 1) {
                esValido = false;
            }

            // Las calles pueden ser nombres o apellidos de personas y/o números
            if (!PersonaValidacion.validarApellido(palabra, true)
                    && !PersonaValidacion.validarNombre(palabra, true)
                    && !CapaValidacion.esTodoNumero(palabra)) {
                esValido = false;
            }
        }
        
        return esValido;
    }

    /**
     * Valida la provincia de una persona. No debe ser vacía.
     *
     * @param unaProvincia Texto que indica la provincia
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarProvincia(String unaProvincia,
            boolean esObligatorio) {
        if (esObligatorio) {
            return !unaProvincia.isEmpty();
        }

        return true;
    }

    /**
     * Valida la Localidad de una provincia. Sólo será vacía en caso de que
     * la provincia sea la Ciudad Autónoma de Buenos Aires.
     *
     * @param objetoProvincia Componente seleccionado del Combobox que indica
     * la provincia
     * @param objetoLocalidad Componente seleccionado del Combobox que indica
     * la localidad
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarLocalidad(Object objetoProvincia,
            Object objetoLocalidad, boolean esObligatorio) {
        boolean esValido = true;
        String objetoProvinciaTemp = null;
        String objetoLocalidadTemp = null;

        if (esObligatorio && objetoProvincia == null && objetoLocalidad == null) {
            esValido = false;
        } else if (esObligatorio &&
                (objetoProvincia != null && objetoProvincia.toString().isEmpty()) &&
                (objetoLocalidad != null && objetoLocalidad.toString().isEmpty())) {
            esValido = false;
        } else if (esObligatorio &&
                (objetoProvincia == null) &&
                (objetoLocalidad != null && objetoLocalidad.toString().isEmpty())) {
            esValido = false;
        } else if (esObligatorio &&
                (objetoProvincia != null && objetoProvincia.toString().isEmpty()) &&
                (objetoLocalidad == null)) {
            esValido = false;
        }

        if (objetoProvincia != null) {
            objetoProvinciaTemp = objetoProvincia.toString();
        }
        if (objetoLocalidad != null) {
            objetoLocalidadTemp = objetoLocalidad.toString();
        }

        if (objetoLocalidadTemp != null) {
            if (objetoLocalidadTemp.isEmpty() &&
                    (objetoProvinciaTemp.isEmpty() || objetoProvinciaTemp.
                    equalsIgnoreCase(
                    "ciudad autónoma de buenos aires"))) {
                ;
            } else if (!objetoLocalidadTemp.isEmpty() &&
                    (!objetoProvinciaTemp.isEmpty() && !objetoProvinciaTemp.
                    equalsIgnoreCase(
                    "ciudad autónoma de buenos aires"))) {
                ;
            } else {
                esValido = false;
            }
        } else if (objetoProvinciaTemp.isEmpty() || objetoProvinciaTemp.
                equalsIgnoreCase(
                    "ciudad autónoma de buenos aires")) {
            ;
        } else {
            esValido = false;
        }

        return esValido;
    }

    /**
     * Valida un código postal de una persona, debe ser de 4 números o vacío.
     * 
     * @param unCodigoPostal El código postal de la persona
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarCodigoPostal(String unCodigoPostal,
            boolean esObligatorio) {
        boolean esValido = true;

        if (esObligatorio && (unCodigoPostal.isEmpty() ||
                unCodigoPostal.length() != 4)) {
            esValido = false;
        } else if (!esObligatorio && !unCodigoPostal.isEmpty() &&
                unCodigoPostal.length() != 4) {
            esValido = false;
        }
        
        if (esValido && !CapaValidacion.esTodoNumero(unCodigoPostal)) {
            esValido = false;
        }

        return esValido;
    }

    /**
     * Determina si el correo electrónico es válido.
     *
     * @param correoElectronico El teléfono particular
     * @param esObligatorio Obligatoriedad del campo
     * @return true si es válido, false en caso contrario
     */
    public static boolean validarCorreoElectronico(String correoElectronico,
            boolean esObligatorio) {
       /*
        * Construimos la expresión regular que nos permite ingresar correos
        * electrónicos con formatos válidos como:
        * mensaje@elguille.info pepe.luis@algo.com.es,
        * y no válidos en los siguientes casos:
        * notedoy@micorreo posvale@pepo.n
        */
        boolean esValido = true;
        String correoElectronicoTemp = correoElectronico.toLowerCase();

        //El correo puede ser vacío
        if (esObligatorio && correoElectronicoTemp.isEmpty()) {
            esValido = false;
        }

        Pattern patron = Pattern.compile(
                "^[0-9a-z_\\-\\.]+@[0-9a-z\\-\\.]+\\.[a-z]{2,4}$");
        if (!correoElectronicoTemp.isEmpty() &&
                !patron.matcher(correoElectronicoTemp).matches()) {
            esValido = false;
        }

        return esValido;
    }
    
}
